.TH std::dynamic_extent 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::dynamic_extent \- std::dynamic_extent

.SH Synopsis
   Defined in header <span>
   inline constexpr std::size_t dynamic_extent =                          \fI(since C++20)\fP
   std::numeric_limits<std::size_t>::max();

   std::dynamic_extent is a constant of type std::size_t that is generally used to
   indicate that any type using std::dynamic_extent will dynamically store its value
   (e.g., size) rather than having the value statically known in the type.

   It is being used in several contexts:

     * To differentiate std::span of static and dynamic extent.

     * To indicate that the extent at a certain rank index will be stored (since C++23)
       dynamically in std::extents.

     * To indicate that the padded layouts for std::mdspan will           (since C++26)
       dynamically store its padding value.

.SH Note

   Since std::size_t is an unsigned type, an equivalent definition is:

 inline constexpr std::size_t dynamic_extent = -1;

   See integral conversions.

.SH Example


// Run this code

 #include <array>
 #include <cassert>
 #include <cstddef>
 #include <iostream>
 #include <span>
 #include <string_view>
 #include <vector>

 int main()
 {
     auto print = [](std::string_view const name, std::size_t ex)
     {
         std::cout << name << ", ";
         if (std::dynamic_extent == ex)
             std::cout << "dynamic extent\\n";
         else
             std::cout << "static extent = " << ex << '\\n';
     };

     int a[]{1, 2, 3, 4, 5};

     std::span span1{a};
     print("span1", span1.extent);

     std::span<int, std::dynamic_extent> span2{a};
     print("span2", span2.extent);

     std::array ar{1, 2, 3, 4, 5};
     std::span span3{ar};
     print("span3", span3.extent);

     std::vector v{1, 2, 3, 4, 5};
     std::span span4{v};
     print("span4", span4.extent);
 }

.SH Output:

 span1, static extent = 5
 span2, dynamic extent
 span3, static extent = 5
 span4, dynamic extent

.SH See also

   span    a non-owning view over a contiguous sequence of objects
   (C++20) \fI(class template)\fP
   extents a descriptor of a multidimensional index space of some rank
   (C++23) \fI(class template)\fP
